package com.javastudy.liuhouse.lambda.stream;

import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class OtherStream {

    @Test
    public void testSorted() {
        //创建一个字符串类型的List列表
        //按照ASCILL进行排序的
//        List<String> list = List.of("Orange" , "apple" , "Banana");
//        List<String> collect = list.stream().sorted().collect(Collectors.toList());
//        System.out.println(collect);

        //默认是按照从小到大的顺序进行排序的
        //对stream的元素进行排十分简单,只需要调用sorted()方法
//        List<Integer> list = List.of(10 , 5 , 8 , 20).stream().sorted().collect(Collectors.toList());
//        System.out.println(list);

        //此方法要求Stream的每个元素必须实现 Comparable接口,如果要自定义排序,传入指定的Compare即可
        //注意 sorted()  只是一个转换操作,他会返回一个新的Stream
        List<String> list = List.of("Orange", "apple", "Banana")
                .stream()
                .sorted(String::compareToIgnoreCase)
                .collect(Collectors.toUnmodifiableList());
        Collectors.toList()
        ;
        System.out.println(list);
    }

    //去重操作
    @Test
    public void testDistinct(){
        //对一个Stream元素进行去重,没有必要先转化为Set，可以直接使用 distinct()
        List<String> list = List.of("A" , "B" , "A" , "C" , "B" , "D");
        List<String> collect = list.stream().distinct().collect(Collectors.toList());
        System.out.println(collect);
    }


    //截取
    @Test
    public void testSkip(){
        //截取操作常用于把一个无限的stream转换成一个有限的stream,skip()用于跳过当前Stream的千N个元素
        //limit()用于截取当前Stream的最多前N个元素
        //截取操作也是一个转换操作,将返回一个新的Stream
        List<String> list = List.of("A" , "B" , "C" , "D" , "E" , "F")
                .stream()
                .skip(2)//跳过A,B
                .limit(3)//截取C,D,E
                .collect(Collectors.toList());
        System.out.println(list);
    }


    //合并
    @Test
    public void textConcat(){
        //将两个Stream合并为一个Stream可以使用Stream的静态方法 concat
        Stream<String> s1 = List.of("A" , "B" , "C").stream();
        Stream<String> s2 = List.of("D" , "E").stream();
        //合并
        //其实底层很简单  无非就是把两个 列表拿过来  然后声明一个空数组 ，然后都放入到一个数组中
        Stream<String> s = Stream.concat(s1, s2);
        System.out.println(s.collect(Collectors.toList()));
    }

    //flatMap
    //如果Stream的元素是集合
    @Test
    public void testStream(){
        //如果Stream的元素是集合
        Stream<List<Integer>> s = Stream.of(
                Arrays.asList(1, 2, 3),
                Arrays.asList(4, 5, 6),
                Arrays.asList(7, 8, 9)
        );
        //我们希望吧上述的Stream转换为Stream<Integer>,就可以使用flatMap()
        Stream<Integer> i = s.flatMap(list -> list.stream());
        System.out.println(i.collect(Collectors.toList()));
    }


    //并行
    //经过parallel()转换后的Stream只要可能，
    //就会对后续操作进行并行处理。我们不需要编写任何多线程代码就可以享受到并行处理带来的执行效率的提升。
    @Test
    public void testParallel(){
        List<String> list = List.of("Orange", "apple", "Banana");
        Stream<String> stream = list.stream();
        String[] array = stream
                .parallel()//变成一个并行处理的Stream
                .sorted() //可以进行并行排序
                .toArray(String[]::new);
        for(String s : array){
            System.out.println(s);
        }
    }



}
